home *** CD-ROM | disk | FTP | other *** search
/ Mission 3 / Mission 3.zip / Mission 3.iso / texte / 7up_pd / macrorec.c < prev    next >
C/C++ Source or Header  |  1998-10-29  |  5KB  |  202 lines
  1. /* Aufzeichnung und Wiedergabe von Tastaturdrücken, siehe auch mevent.c */
  2. /*****************************************************************************
  3. *
  4. *                                   7UP
  5. *                             Modul: MACROREC.C
  6. *                            (c) by TheoSoft '94
  7. *
  8. *****************************************************************************/
  9. #include <portab.h>
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <ctype.h>
  14. #include <aes.h>
  15.  
  16. #include "windows.h"
  17. #include "7up.h"
  18. #include "version.h"
  19. #include "macro.h"
  20.  
  21. #include "alert.h"
  22.  
  23. #define MAXLONGINT 0x7FFFFFFF
  24.  
  25. TMACRO macro = {VERSIONNAME,0x0100,sizeof(TMACRO)-sizeof(void *),0L,0L,0L,0L,0L,0L,0L,NULL};
  26.  
  27. int record_macro(int command, int kstate, int key) 
  28. {
  29.     TMACROBUFF *ip;
  30.     
  31.     switch(command)
  32.     {
  33.         case MACREC:
  34.             if(macro.mp)
  35.                 free(macro.mp);
  36.            macro.mp=(TMACROBUFF *)malloc(MAX_MACROS*sizeof(TMACROBUFF));
  37.             if(macro.mp)
  38.             {
  39.                 macro.size  = MAX_MACROS;
  40.                 macro.rec   = TRUE;
  41.                 macro.play  = FALSE;
  42.                 macro.macroindex = 0;
  43.                 macro.lastmacro = -1;
  44.                 macro.lastrep = 1;
  45.                 memset(macro.mp, 0, MAX_MACROS*sizeof(TMACROBUFF));
  46.             }
  47.             return(0);
  48.             break;
  49.         case MACSTOP:
  50.             if(macro.rec)
  51.                 macro.rec = FALSE;
  52.             return(0);
  53.             break;
  54.         case MACPLAY:
  55.             if(macro.mp)
  56.             {
  57.                 macro.macroindex = 0;
  58.                 macro.repindex   = 0;
  59.                 macro.rec  = FALSE;
  60.                 macro.play = TRUE;
  61.             }
  62.             return(0);
  63.             break;
  64.         default:
  65.             if(macro.rec)
  66.             {
  67.                 if(macro.lastmacro==-1) /* als erstes die Wiederholrate */
  68.                 {
  69.                     if(isdigit(key)) /* Ziffer? */
  70.                     {
  71.                         macro.lastrep=(int)((char)key-'0'); /* 1-9 erlaubt */
  72.                         macro.lastmacro++;
  73.                     }
  74.                     else /* Ziffer!!! */
  75.                     {
  76.                         macro.rec = FALSE; /* Fehler, halt! */
  77.                         form_alert(1,Amacrorec[0]);
  78.                     }
  79.                     return(0);
  80.                 }
  81.                 else
  82.                 {
  83.                     if(macro.lastmacro < macro.size) /* paßt das Zeichen noch in den Puffer */
  84.                     {
  85.                         macro.mp[macro.lastmacro].kstate = kstate;
  86.                         macro.mp[macro.lastmacro].key    = key;
  87.                         macro.lastmacro++;
  88.                     }
  89.                     else /* Makroplatz ist zu klein, erweitern wir ihn */
  90.                     {
  91.                         if(macro.size + MAX_MACROS <= MAXLONGINT) 
  92.                         {  /* immer um 256 erweitern, aber nicht mehr als 2^31-1 */
  93.                             ip = (TMACROBUFF *)realloc(macro.mp,(macro.size+MAX_MACROS)*sizeof(TMACROBUFF));
  94.                             if(ip) /* der Platz reicht */
  95.                             {
  96.                                 macro.mp    = ip;      /* Pointer auf neuen Wert */
  97.                                 macro.size += MAX_MACROS; /* Puffer größer machen */
  98.                                 /* das letzte Zeichen nehmen wir aber noch mit! */
  99.                                 macro.mp[macro.lastmacro].kstate = kstate;
  100.                                 macro.mp[macro.lastmacro].key    = key;
  101.                                 macro.lastmacro++;
  102.                             }
  103.                             else /* leider kein Speicher mehr frei */
  104.                             {
  105.                                 form_alert(1,Amacrorec[1]);
  106.                                 macro.rec = FALSE;
  107.                             }
  108.                         }
  109.                         else /* max. Makrogröße erreicht */
  110.                         {    
  111.                             form_alert(1,Amacrorec[1]);
  112.                             macro.rec = FALSE;
  113.                         }
  114.                     }
  115.                 }
  116.             }
  117.             return(MU_KEYBD);
  118.             break;
  119.     }
  120. }
  121.  
  122. int play_macro(int *kstate, int *key)
  123. {
  124.     if(macro.repindex < macro.lastrep)
  125.     {
  126.         if(macro.macroindex < macro.lastmacro)
  127.         {
  128.              *kstate = macro.mp[macro.macroindex].kstate;
  129.             *key      = macro.mp[macro.macroindex].key;
  130.             macro.macroindex++;
  131.             return(MU_KEYBD|MU_TIMER);
  132.         }
  133.         macro.macroindex=0;
  134.         macro.repindex++;
  135.         return(0);
  136.     }
  137.     macro.repindex=1;
  138.     macro.play=FALSE;
  139.     return(0);
  140. }
  141.  
  142. void _loadmacro(char *filename)
  143. {
  144.     FILE *fp;
  145.  
  146.     if((fp=fopen(filename,"rb"))!=NULL)
  147.     {
  148.         if(macro.mp) /* alten Müll freigeben */
  149.             free(macro.mp);
  150.         fread(¯o,sizeof(TMACRO),1,fp); /* Kopf laden */
  151.        macro.mp=(TMACROBUFF *)malloc(macro.size*sizeof(TMACROBUFF));
  152.         if(macro.mp) /* Speicher angefordert */
  153.             fread(macro.mp,macro.size*sizeof(TMACROBUFF),1,fp); /* hinein damit */
  154.         fclose(fp);
  155.     }
  156. }
  157.  
  158. void loadmacro(void)
  159. {
  160.     char *cp, filename[PATH_MAX]="";
  161.     /*static*/ char fpattern[FILENAME_MAX]="*.*";
  162.  
  163.     strcpy(fpattern,"*.MAC");
  164.     find_7upinf(filename,"MAC",TRUE /*FALSE*/);
  165.     if((cp=strrchr(filename,'\\'))!=NULL)
  166.         strcpy(&cp[1],fpattern);
  167.     else
  168.         *filename=0;
  169.     if(getfilename(filename,fpattern,"@",fselmsg[28]))
  170.         _loadmacro(filename);
  171. }
  172.  
  173. void _savemacro(char *filename)
  174. {
  175.     FILE *fp;
  176.  
  177.     if(!macro.mp)
  178.         return;
  179.  
  180.     if((fp=fopen(filename,"wb"))!=NULL)
  181.     {
  182.         fwrite(¯o,sizeof(TMACRO),1,fp); /* Kopfdaten schreiben */
  183.         fwrite(macro.mp,macro.size*sizeof(TMACROBUFF),1,fp); /* Makros schreiben */
  184.         fclose(fp);
  185.     }
  186. }
  187.  
  188. void savemacro(void)
  189. {
  190.     char *cp, filename[PATH_MAX]="";
  191.     /*static*/ char fpattern[FILENAME_MAX]="*.*";
  192.  
  193.     strcpy(fpattern,"*.MAC");
  194.     find_7upinf(filename,"MAC",TRUE /*FALSE*/);
  195.     if((cp=strrchr(filename,'\\'))!=NULL)
  196.         strcpy(&cp[1],fpattern);
  197.     else
  198.         *filename=0;
  199.     if(getfilename(filename,fpattern,"@",fselmsg[29]))
  200.         _savemacro(filename);
  201. }
  202.